home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 October: Mac OS SDK / Dev.CD Oct 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Universal / Interfaces / CIncludes / FSM.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-08-12  |  34.1 KB  |  979 lines  |  [TEXT/MPS ]

  1. /*
  2.      File:        FSM.h
  3.  
  4.      Contains:    HFS External File System Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Release:    Universal Interfaces 3.0.1
  8.  
  9.      Copyright:    © 1985-1997 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        Please include the the file and version information (from above) with
  12.                  the problem description.  Developers belonging to one of the Apple
  13.                  developer programs can submit bug reports to:
  14.  
  15.                      devsupport@apple.com
  16.  
  17. */
  18. #ifndef __FSM__
  19. #define __FSM__
  20.  
  21. #ifndef __FILES__
  22. #include <Files.h>
  23. #endif
  24.  
  25.  
  26.  
  27. #if PRAGMA_ONCE
  28. #pragma once
  29. #endif
  30.  
  31. #ifdef __cplusplus
  32. extern "C" {
  33. #endif
  34.  
  35. #if PRAGMA_IMPORT
  36. #pragma import on
  37. #endif
  38.  
  39. #if PRAGMA_STRUCT_ALIGN
  40.     #pragma options align=mac68k
  41. #elif PRAGMA_STRUCT_PACKPUSH
  42.     #pragma pack(push, 2)
  43. #elif PRAGMA_STRUCT_PACK
  44.     #pragma pack(2)
  45. #endif
  46.  
  47. /* VolMount declarations are now in Files.≈ */
  48.  
  49. /*
  50.  * Miscellaneous file system values not in Files.≈
  51.  */
  52.  
  53. enum {
  54.     fsUsrCNID                    = 16,                            /* First assignable directory or file number */
  55.                                                                 /*    File system trap word attribute bits */
  56.     kHFSBit                        = 9,                            /* HFS call: bit 9 */
  57.     kHFSMask                    = 0x0200,
  58.     kAsyncBit                    = 10,                            /* Asynchronous call: bit 10 */
  59.     kAsyncMask                    = 0x0400
  60. };
  61.  
  62.  
  63. /*
  64.  * HFSCIProc selectCode values
  65.  * Note: The trap attribute bits (the HFS bit and the asynchronous bit)
  66.  * may be set in these selectCode values.
  67.  */
  68.  
  69. enum {
  70.     kFSMOpen                    = 0xA000,
  71.     kFSMClose                    = 0xA001,
  72.     kFSMRead                    = 0xA002,
  73.     kFSMWrite                    = 0xA003,
  74.     kFSMGetVolInfo                = 0xA007,
  75.     kFSMCreate                    = 0xA008,
  76.     kFSMDelete                    = 0xA009,
  77.     kFSMOpenRF                    = 0xA00A,
  78.     kFSMRename                    = 0xA00B,
  79.     kFSMGetFileInfo                = 0xA00C,
  80.     kFSMSetFileInfo                = 0xA00D,
  81.     kFSMUnmountVol                = 0xA00E,
  82.     kFSMMountVol                = 0xA00F,
  83.     kFSMAllocate                = 0xA010,
  84.     kFSMGetEOF                    = 0xA011,
  85.     kFSMSetEOF                    = 0xA012,
  86.     kFSMFlushVol                = 0xA013,
  87.     kFSMGetVol                    = 0xA014,
  88.     kFSMSetVol                    = 0xA015,
  89.     kFSMEject                    = 0xA017,
  90.     kFSMGetFPos                    = 0xA018,
  91.     kFSMOffline                    = 0xA035,
  92.     kFSMSetFilLock                = 0xA041,
  93.     kFSMRstFilLock                = 0xA042,
  94.     kFSMSetFilType                = 0xA043,
  95.     kFSMSetFPos                    = 0xA044,
  96.     kFSMFlushFile                = 0xA045,                        /*    The File System HFSDispatch selectCodes */
  97.     kFSMOpenWD                    = 0x0001,
  98.     kFSMCloseWD                    = 0x0002,
  99.     kFSMCatMove                    = 0x0005,
  100.     kFSMDirCreate                = 0x0006,
  101.     kFSMGetWDInfo                = 0x0007,
  102.     kFSMGetFCBInfo                = 0x0008,
  103.     kFSMGetCatInfo                = 0x0009,
  104.     kFSMSetCatInfo                = 0x000A,
  105.     kFSMSetVolInfo                = 0x000B,
  106.     kFSMLockRng                    = 0x0010,
  107.     kFSMUnlockRng                = 0x0011,
  108.     kFSMXGetVolInfo                = 0x0012,
  109.     kFSMCreateFileIDRef            = 0x0014,
  110.     kFSMDeleteFileIDRef            = 0x0015,
  111.     kFSMResolveFileIDRef        = 0x0016,
  112.     kFSMExchangeFiles            = 0x0017,
  113.     kFSMCatSearch                = 0x0018,
  114.     kFSMOpenDF                    = 0x001A,
  115.     kFSMMakeFSSpec                = 0x001B,                        /*    The Desktop Manager HFSDispatch selectCodes */
  116.     kFSMDTGetPath                = 0x0020,
  117.     kFSMDTCloseDown                = 0x0021,
  118.     kFSMDTAddIcon                = 0x0022,
  119.     kFSMDTGetIcon                = 0x0023,
  120.     kFSMDTGetIconInfo            = 0x0024,
  121.     kFSMDTAddAPPL                = 0x0025,
  122.     kFSMDTRemoveAPPL            = 0x0026,
  123.     kFSMDTGetAPPL                = 0x0027,
  124.     kFSMDTSetComment            = 0x0028,
  125.     kFSMDTRemoveComment            = 0x0029,
  126.     kFSMDTGetComment            = 0x002A,
  127.     kFSMDTFlush                    = 0x002B,
  128.     kFSMDTReset                    = 0x002C,
  129.     kFSMDTGetInfo                = 0x002D,
  130.     kFSMDTOpenInform            = 0x002E,
  131.     kFSMDTDelete                = 0x002F,                        /*    The AppleShare HFSDispatch selectCodes */
  132.     kFSMGetVolParms                = 0x0030,
  133.     kFSMGetLogInInfo            = 0x0031,
  134.     kFSMGetDirAccess            = 0x0032,
  135.     kFSMSetDirAccess            = 0x0033,
  136.     kFSMMapID                    = 0x0034,
  137.     kFSMMapName                    = 0x0035,
  138.     kFSMCopyFile                = 0x0036,
  139.     kFSMMoveRename                = 0x0037,
  140.     kFSMOpenDeny                = 0x0038,
  141.     kFSMOpenRFDeny                = 0x0039,
  142.     kFSMGetXCatInfo                = 0x003A,
  143.     kFSMGetVolMountInfoSize        = 0x003F,
  144.     kFSMGetVolMountInfo            = 0x0040,
  145.     kFSMVolumeMount                = 0x0041,
  146.     kFSMShare                    = 0x0042,
  147.     kFSMUnShare                    = 0x0043,
  148.     kFSMGetUGEntry                = 0x0044,
  149.     kFSMGetForeignPrivs            = 0x0060,
  150.     kFSMSetForeignPrivs            = 0x0061
  151. };
  152.  
  153. /*
  154.  * UTDetermineVol status values
  155.  */
  156.  
  157. enum {
  158.     dtmvError                    = 0,                            /* param error */
  159.     dtmvFullPathame                = 1,                            /* determined by full pathname */
  160.     dtmvVRefNum                    = 2,                            /* determined by volume refNum */
  161.     dtmvWDRefNum                = 3,                            /* determined by working directory refNum */
  162.     dtmvDriveNum                = 4,                            /* determined by drive number */
  163.     dtmvDefault                    = 5                                /* determined by default volume */
  164. };
  165.  
  166.  
  167. /*
  168.  * UTGetBlock options
  169.  */
  170.  
  171. enum {
  172.     gbDefault                    = 0,                            /* default value - read if not found */
  173.                                                                 /*    bits and masks */
  174.     gbReadBit                    = 0,                            /* read block from disk (forced read) */
  175.     gbReadMask                    = 0x0001,
  176.     gbExistBit                    = 1,                            /* get existing cache block */
  177.     gbExistMask                    = 0x0002,
  178.     gbNoReadBit                    = 2,                            /* don't read block from disk if not found in cache */
  179.     gbNoReadMask                = 0x0004,
  180.     gbReleaseBit                = 3,                            /* release block immediately after GetBlock */
  181.     gbReleaseMask                = 0x0008
  182. };
  183.  
  184.  
  185. /*
  186.  * UTReleaseBlock options
  187.  */
  188.  
  189. enum {
  190.     rbDefault                    = 0,                            /* default value - just mark the buffer not in-use */
  191.                                                                 /*    bits and masks */
  192.     rbWriteBit                    = 0,                            /* force write buffer to disk */
  193.     rbWriteMask                    = 0x0001,
  194.     rbTrashBit                    = 1,                            /* trash buffer contents after release */
  195.     rbTrashMask                    = 0x0002,
  196.     rbDirtyBit                    = 2,                            /* mark buffer dirty */
  197.     rbDirtyMask                    = 0x0004,
  198.     rbFreeBit                    = 3,                            /* free the buffer (save in the hash) */
  199.     rbFreeMask                    = 0x000A                        /* rbFreeMask (rbFreeBit + rbTrashBit) works as rbTrash on < System 7.0 RamCache; on >= System 7.0, rbfreeMask overrides rbTrash */
  200. };
  201.  
  202.  
  203. /*
  204.  * UTFlushCache options
  205.  */
  206.  
  207. enum {
  208.     fcDefault                    = 0,                            /* default value - pass this fcOption to just flush any dirty buffers */
  209.                                                                 /*    bits and masks */
  210.     fcTrashBit                    = 0,                            /* (don't pass this as fcOption, use only for testing bit) */
  211.     fcTrashMask                    = 0x0001,                        /* pass this fcOption value to flush and trash cache blocks */
  212.     fcFreeBit                    = 1,                            /* (don't pass this as fcOption, use only for testing bit) */
  213.     fcFreeMask                    = 0x0003                        /* pass this fcOption to flush and free cache blocks (Note: both fcTrash and fcFree bits are set) */
  214. };
  215.  
  216.  
  217. /*
  218.  * UTCacheReadIP and UTCacheWriteIP cacheOption
  219.  */
  220.  
  221. enum {
  222.     noCacheBit                    = 5,                            /* don't cache this please */
  223.     noCacheMask                    = 0x0020,
  224.     rdVerifyBit                    = 6,                            /* read verify */
  225.     rdVerifyMask                = 0x0040
  226. };
  227.  
  228.  
  229. /*
  230.  * Cache routine internal error codes
  231.  */
  232.  
  233. enum {
  234.     chNoBuf                        = 1,                            /* no free cache buffers (all in use) */
  235.     chInUse                        = 2,                            /* requested block in use */
  236.     chnotfound                    = 3,                            /* requested block not found */
  237.     chNotInUse                    = 4                                /* block being released was not in use */
  238. };
  239.  
  240.  
  241. /*
  242.  * FCBRec.fcbFlags bits
  243.  */
  244.  
  245. enum {
  246.     fcbWriteBit                    = 0,                            /* Data can be written to this file */
  247.     fcbWriteMask                = 0x01,
  248.     fcbResourceBit                = 1,                            /* This file is a resource fork */
  249.     fcbResourceMask                = 0x02,
  250.     fcbWriteLockedBit            = 2,                            /* File has a locked byte range */
  251.     fcbWriteLockedMask            = 0x04,
  252.     fcbSharedWriteBit            = 4,                            /* File is open for shared write access */
  253.     fcbSharedWriteMask            = 0x10,
  254.     fcbFileLockedBit            = 5,                            /* File is locked (write-protected) */
  255.     fcbFileLockedMask            = 0x20,
  256.     fcbOwnClumpBit                = 6,                            /* File has clump size specified in FCB */
  257.     fcbOwnClumpMask                = 0x40,
  258.     fcbModifiedBit                = 7,                            /* File has changed since it was last flushed */
  259.     fcbModifiedMask                = 0x80
  260. };
  261.  
  262.  
  263. /*
  264.  * ExtFileProc options
  265.  */
  266.  
  267. enum {
  268.     extendFileAllBit            = 0,                            /* allocate all requested bytes or none */
  269.     extendFileAllMask            = 0x0001,
  270.     extendFileContigBit            = 1,                            /* force contiguous allocation */
  271.     extendFileContigMask        = 0x0002
  272. };
  273.  
  274.  
  275. /*
  276.  *    HFS Component Interface constants
  277.  */
  278.  
  279. /*
  280.  * compInterfMask bits specific to HFS component
  281.  */
  282.  
  283. enum {
  284.     hfsCIDoesHFSBit                = 23,                            /* set if file system supports HFS calls */
  285.     hfsCIDoesHFSMask            = 0x00800000,
  286.     hfsCIDoesAppleShareBit        = 22,                            /* set if AppleShare calls supported */
  287.     hfsCIDoesAppleShareMask        = 0x00400000,
  288.     hfsCIDoesDeskTopBit            = 21,                            /* set if Desktop Database calls supported */
  289.     hfsCIDoesDeskTopMask        = 0x00200000,
  290.     hfsCIDoesDynamicLoadBit        = 20,                            /* set if dynamically loading code resource */
  291.     hfsCIDoesDynamicLoadMask    = 0x00100000,                    /*        supported */
  292.     hfsCIResourceLoadedBit        = 19,                            /* set if code resource already loaded */
  293.     hfsCIResourceLoadedMask        = 0x00080000,
  294.     hfsCIHasHLL2PProcBit        = 18,                            /* set if FFS' log2PhyProc and Extendfile proc */
  295.     hfsCIHasHLL2PProcMask        = 0x00040000,                    /* is written in a high level language. (i.e., uses Pascal calling convention) */
  296.     hfsCIWantsDTSupportBit        = 17,                            /* set if FFS wants the Mac OS's Desktop Manager code to handle */
  297.     hfsCIWantsDTSupportMask        = 0x00020000                    /* all Desktop Manager requests to its volumes. */
  298. };
  299.  
  300.  
  301. /*
  302.  *    Disk Initialization Component Interface constants
  303.  */
  304.  
  305. /*
  306.  * compInterfMask bits specific to Disk Initialization component
  307.  */
  308.  
  309. enum {
  310.     diCIHasExtFormatParamsBit    = 18,                            /* set if file system needs extended format */
  311.     diCIHasExtFormatParamsMask    = 0x00040000,                    /*        parameters */
  312.     diCIHasMultiVolTypesBit        = 17,                            /* set if file system supports more than one */
  313.     diCIHasMultiVolTypesMask    = 0x00020000,                    /*        volume type */
  314.     diCIDoesSparingBit            = 16,                            /* set if file system supports disk sparing */
  315.     diCIDoesSparingMask            = 0x00010000,
  316.     diCILiveBit                    = 0,                            /* set if file system is candidate for current */
  317.     diCILiveMask                = 0x00000001                    /*        formatting operation (set by PACK2) */
  318. };
  319.  
  320.  
  321. /*
  322.  * Disk Initialization Component Function selectors
  323.  */
  324.  
  325. enum {
  326.     diCILoad                    = 1,                            /* Make initialization code memory resident */
  327.     diCIUnload                    = 2,                            /* Make initialization code purgeable */
  328.     diCIEvaluateSizeChoices        = 3,                            /* Evaluate size choices */
  329.     diCIExtendedZero            = 4,                            /* Write an empty volume directory */
  330.     diCIValidateVolName            = 5,                            /* Validate volume name */
  331.     diCIGetVolTypeInfo            = 6,                            /* get volume type info */
  332.     diCIGetFormatString            = 7,                            /* get dialog format string */
  333.     diCIGetExtFormatParams        = 8,                            /* get extended format parameters */
  334.     diCIGetDefectList            = 9                                /* return the defect list for the indicated disk - reserved for future use */
  335. };
  336.  
  337.  
  338. /*
  339.  * Constants used in the DICIEvaluateSizeRec and FormatListRec
  340.  */
  341.  
  342. enum {
  343.     diCIFmtListMax                = 8,                            /* maximum number of format list entries in DICIEvaluateSizeRec.numSizeEntries */
  344.                                                                 /*    bits in FormatListRec.formatFlags: */
  345.     diCIFmtFlagsValidBit        = 7,                            /* set if sec, side, tracks valid */
  346.     diCIFmtFlagsValidMask        = 0x80,
  347.     diCIFmtFlagsCurrentBit        = 6,                            /* set if current disk has this fmt */
  348.     diCIFmtFlagsCurrentMask        = 0x40,                            /*    bits in FormatListRec.sizeListFlags: */
  349.     diCISizeListOKBit            = 15,                            /* set if this disk size usable */
  350.     diCISizeListOKMask            = 0x8000
  351. };
  352.  
  353.  
  354. /*
  355.  * DICIGetFormatStringRec.stringKind format strings
  356.  */
  357.  
  358. enum {
  359.     diCIAlternateFormatStr        = 1,                            /* get alternate format  string (Balloon Help) */
  360.     diCISizePresentationStr        = 2                                /* get size presentation string (for dialog) */
  361. };
  362.  
  363.  
  364. /*
  365.  * Error codes returned by Disk Sparing
  366.  */
  367.  
  368. enum {
  369.     diCIUserCancelErr            = 1,                            /* user cancelled the disk init */
  370.     diCICriticalSectorBadErr    = 20,                            /* critical sectors are bad (hopeless)    */
  371.     diCISparingFailedErr        = 21,                            /* disk cannot be spared */
  372.     diCITooManyBadSectorsErr    = 22,                            /* too many bad sectors */
  373.     diCIUnknownVolTypeErr        = 23,                            /* the volume type passed in diCIExtendedZero paramBlock is not supported */
  374.     diCIVolSizeMismatchErr        = 24,                            /* specified volume size doesn’t match with formatted disk size */
  375.     diCIUnknownDICallErr        = 25,                            /* bogus DI function call selector */
  376.     diCINoSparingErr            = 26,                            /* disk is bad but the target FS doesn't do disk sparing */
  377.     diCINoExtendInfoErr            = 27,                            /* missing file system specific extra parameter in diCIExtendedZero call */
  378.     diCINoMessageTextErr        = 28                            /* missing message text in DIReformat call */
  379. };
  380.  
  381.  
  382. /*
  383.  *    File System Manager constants
  384.  */
  385.  
  386. /*
  387.  * Miscellaneous constants used by FSM
  388.  */
  389.  
  390. enum {
  391.     fsdVersion1                    = 1,                            /* current version of FSD record */
  392.     fsmIgnoreFSID                = 0xFFFE,                        /* this FSID should be ignored by the driver */
  393.     fsmGenericFSID                = 0xFFFF                        /* unknown foreign file system ID */
  394. };
  395.  
  396.  
  397. /*
  398.  * compInterfMask bits common to all FSM components
  399.  */
  400.  
  401. enum {
  402.     fsmComponentEnableBit        = 31,                            /* set if FSM component interface is enabled */
  403.     fsmComponentEnableMask        = (long)0x80000000,
  404.     fsmComponentBusyBit            = 30,                            /* set if FSM component interface is busy */
  405.     fsmComponentBusyMask        = 0x40000000
  406. };
  407.  
  408.  
  409. /*
  410.  * Selectors for GetFSInfo
  411.  */
  412.  
  413. enum {
  414.     fsmGetFSInfoByIndex            = -1,                            /* get fs info by index */
  415.     fsmGetFSInfoByFSID            = 0,                            /* get fs info by FSID */
  416.     fsmGetFSInfoByRefNum        = 1                                /* get fs info by file/vol refnum */
  417. };
  418.  
  419.  
  420. /*
  421.  * InformFSM messages
  422.  */
  423.  
  424. enum {
  425.     fsmNopMessage                = 0,                            /* nop */
  426.     fsmDrvQElChangedMessage        = 1,                            /* DQE has changed */
  427.     fsmGetFSIconMessage            = 2                                /* Get FFS's disk icon */
  428. };
  429.  
  430.  
  431. /*
  432.  * Messages passed to the fileSystemCommProc
  433.  */
  434.  
  435. enum {
  436.     ffsNopMessage                = 0,                            /* nop, should always return noErr */
  437.     ffsGetIconMessage            = 1,                            /* return disk icon and mask */
  438.     ffsIDDiskMessage            = 2,                            /* identify the about-to-be-mounted volume */
  439.     ffsLoadMessage                = 3,                            /* load in the FFS */
  440.     ffsUnloadMessage            = 4,                            /* unload the FFS */
  441.     ffsIDVolMountMessage        = 5,                            /* identify a VolMountInfo record */
  442.     ffsInformMessage            = 6,                            /* FFS defined message */
  443.     ffsGetIconInfoMessage        = 7
  444. };
  445.  
  446.  
  447. /*
  448.  * Error codes from FSM functions
  449.  */
  450.  
  451. enum {
  452.     fsmFFSNotFoundErr            = -431,                            /* Foreign File system does not exist - new Pack2 could return this error too */
  453.     fsmBusyFFSErr                = -432,                            /* File system is busy, cannot be removed */
  454.     fsmBadFFSNameErr            = -433,                            /* Name length not 1 <= length <= 31 */
  455.     fsmBadFSDLenErr                = -434,                            /* FSD size incompatible with current FSM vers */
  456.     fsmDuplicateFSIDErr            = -435,                            /* FSID already exists on InstallFS */
  457.     fsmBadFSDVersionErr            = -436,                            /* FSM version incompatible with FSD */
  458.     fsmNoAlternateStackErr        = -437,                            /* no alternate stack for HFS CI */
  459.     fsmUnknownFSMMessageErr        = -438                            /* unknown message passed to FSM */
  460. };
  461.  
  462.  
  463. /*
  464.  *    HFS Utility routine records
  465.  */
  466.  
  467. /*
  468.  * record used by UTGetPathComponentName
  469.  */
  470. struct ParsePathRec {
  471.     StringPtr                         namePtr;                    /* pathname to parse */
  472.     short                             startOffset;                /* where to start parsing */
  473.     short                             componentLength;            /* the length of the pathname component parsed */
  474.     SignedByte                         moreName;                    /* non-zero if there are more components after this one */
  475.     SignedByte                         foundDelimiter;                /* non-zero if parsing stopped because a colon (:) delimiter was found */
  476. };
  477. typedef struct ParsePathRec ParsePathRec;
  478.  
  479. typedef ParsePathRec *                    ParsePathRecPtr;
  480. struct WDCBRec {
  481.     VCBPtr                             wdVCBPtr;                    /* Pointer to VCB of this working directory */
  482.     long                             wdDirID;                    /* Directory ID number of this working directory */
  483.     long                             wdCatHint;                    /* Hint for finding this working directory */
  484.     long                             wdProcID;                    /* Process that created this working directory */
  485. };
  486. typedef struct WDCBRec WDCBRec;
  487.  
  488. typedef WDCBRec *                        WDCBRecPtr;
  489. struct FCBRec {
  490.     unsigned long                     fcbFlNm;                    /* FCB file number. Non-zero marks FCB used */
  491.     SignedByte                         fcbFlags;                    /* FCB flags */
  492.     SignedByte                         fcbTypByt;                    /* File type byte */
  493.     unsigned short                     fcbSBlk;                    /* File start block (in alloc size blks) */
  494.     unsigned long                     fcbEOF;                        /* Logical length or EOF in bytes */
  495.     unsigned long                     fcbPLen;                    /* Physical file length in bytes */
  496.     unsigned long                     fcbCrPs;                    /* Current position within file */
  497.     VCBPtr                             fcbVPtr;                    /* Pointer to the corresponding VCB */
  498.     Ptr                             fcbBfAdr;                    /* File's buffer address */
  499.     unsigned short                     fcbFlPos;                    /* Directory block this file is in */
  500.                                                                 /* FCB Extensions for HFS */
  501.     unsigned long                     fcbClmpSize;                /* Number of bytes per clump */
  502.     Ptr                             fcbBTCBPtr;                    /* Pointer to B*-Tree control block for file */
  503.     unsigned long                     fcbExtRec[3];                /* First 3 file extents */
  504.     OSType                             fcbFType;                    /* File's 4 Finder Type bytes */
  505.     unsigned long                     fcbCatPos;                    /* Catalog hint for use on Close */
  506.     unsigned long                     fcbDirID;                    /* Parent Directory ID */
  507.     Str31                             fcbCName;                    /* CName of open file */
  508. };
  509. typedef struct FCBRec FCBRec;
  510.  
  511. typedef FCBRec *                        FCBRecPtr;
  512. /*
  513.  *    HFS Component Interface records
  514.  */
  515. typedef CALLBACK_API( OSErr , Lg2PhysProcPtr )(void *fsdGlobalPtr, VCBPtr volCtrlBlockPtr, FCBRecPtr fileCtrlBlockPtr, short fileRefNum, unsigned long filePosition, unsigned long reqCount, unsigned long *volOffset, unsigned long *contiguousBytes);
  516. typedef STACK_UPP_TYPE(Lg2PhysProcPtr)                             Lg2PhysUPP;
  517. enum { uppLg2PhysProcInfo = 0x003FEFE0 };                         /* pascal 2_bytes Func(4_bytes, 4_bytes, 4_bytes, 2_bytes, 4_bytes, 4_bytes, 4_bytes, 4_bytes) */
  518. #define NewLg2PhysProc(userRoutine)                             (Lg2PhysUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppLg2PhysProcInfo, GetCurrentArchitecture())
  519. #define CallLg2PhysProc(userRoutine, fsdGlobalPtr, volCtrlBlockPtr, fileCtrlBlockPtr, fileRefNum, filePosition, reqCount, volOffset, contiguousBytes)  CALL_EIGHT_PARAMETER_UPP((userRoutine), uppLg2PhysProcInfo, (fsdGlobalPtr), (volCtrlBlockPtr), (fileCtrlBlockPtr), (fileRefNum), (filePosition), (reqCount), (volOffset), (contiguousBytes))
  520. typedef CALLBACK_API( OSErr , HFSCIProcPtr )(VCBPtr theVCB, short selectCode, void *paramBlock, void *fsdGlobalPtr, short fsid);
  521. typedef STACK_UPP_TYPE(HFSCIProcPtr)                             HFSCIUPP;
  522. enum { uppHFSCIProcInfo = 0x0000BEE0 };                         /* pascal 2_bytes Func(4_bytes, 2_bytes, 4_bytes, 4_bytes, 2_bytes) */
  523. #define NewHFSCIProc(userRoutine)                                 (HFSCIUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppHFSCIProcInfo, GetCurrentArchitecture())
  524. #define CallHFSCIProc(userRoutine, theVCB, selectCode, paramBlock, fsdGlobalPtr, fsid)  CALL_FIVE_PARAMETER_UPP((userRoutine), uppHFSCIProcInfo, (theVCB), (selectCode), (paramBlock), (fsdGlobalPtr), (fsid))
  525. struct HFSCIRec {
  526.     long                             compInterfMask;                /* component flags */
  527.     HFSCIProcPtr                     compInterfProc;                /* pointer to file system call processing code */
  528.     Lg2PhysProcPtr                     log2PhyProc;                /* pointer to Lg2PhysProc() code */
  529.     Ptr                             stackTop;                    /* file system stack top */
  530.     long                             stackSize;                    /* file system stack size */
  531.     Ptr                             stackPtr;                    /* current file system stack pointer */
  532.     long                             reserved3;                    /* --reserved, must be zero-- */
  533.     long                             idSector;                    /* Sector you need to ID a local volume. For networked volumes, this must be -1 */
  534.     long                             reserved2;                    /* --reserved, must be zero-- */
  535.     long                             reserved1;                    /* --reserved, must be zero-- */
  536. };
  537. typedef struct HFSCIRec HFSCIRec;
  538.  
  539. typedef HFSCIRec *                        HFSCIRecPtr;
  540. /*
  541.  *    Disk Initialization Component Interface records
  542.  */
  543. typedef CALLBACK_API( OSErr , DICIProcPtr )(short whatFunction, void *paramBlock, void *fsdGlobalPtr);
  544. typedef STACK_UPP_TYPE(DICIProcPtr)                             DICIUPP;
  545. enum { uppDICIProcInfo = 0x00000FA0 };                             /* pascal 2_bytes Func(2_bytes, 4_bytes, 4_bytes) */
  546. #define NewDICIProc(userRoutine)                                 (DICIUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppDICIProcInfo, GetCurrentArchitecture())
  547. #define CallDICIProc(userRoutine, whatFunction, paramBlock, fsdGlobalPtr)  CALL_THREE_PARAMETER_UPP((userRoutine), uppDICIProcInfo, (whatFunction), (paramBlock), (fsdGlobalPtr))
  548. struct DICIRec {
  549.     long                             compInterfMask;                /* component flags */
  550.     DICIProcPtr                     compInterfProc;                /* pointer to call processing code */
  551.     short                             maxVolNameLength;            /* maximum length of your volume name */
  552.     unsigned short                     blockSize;                    /* your file system's block size */
  553.     long                             reserved3;                    /* --reserved, must be zero-- */
  554.     long                             reserved2;                    /* --reserved, must be zero-- */
  555.     long                             reserved1;                    /* --reserved, must be zero-- */
  556. };
  557. typedef struct DICIRec DICIRec;
  558.  
  559. typedef DICIRec *                        DICIRecPtr;
  560. /*
  561.  * FormatListRec as returned by the .Sony disk driver's
  562.  * Return Format List status call (csCode = 6).
  563.  * If the status call to get this list for a drive is not
  564.  * implemented by the driver, then a list with one entry
  565.  * is contructed from the drive queue element for the drive.
  566.  */
  567. struct FormatListRec {
  568.     unsigned long                     volSize;                    /* disk capacity in SECTORs */
  569.     SignedByte                         formatFlags;                /* flags */
  570.     SignedByte                         sectorsPerTrack;            /* sectors per track side */
  571.     unsigned short                     tracks;                        /* number of tracks */
  572. };
  573. typedef struct FormatListRec FormatListRec;
  574.  
  575. typedef FormatListRec *                    FormatListRecPtr;
  576. /*
  577.  * SizeListRec built from FormatListRecs as described above.
  578.  */
  579. struct SizeListRec {
  580.     short                             sizeListFlags;                /* flags as set by external file system */
  581.     FormatListRec                     sizeEntry;                    /* disk driver format list record */
  582. };
  583. typedef struct SizeListRec SizeListRec;
  584.  
  585. typedef SizeListRec *                    SizeListRecPtr;
  586. /*
  587.  * paramBlock for the diCIEvaluateSize call
  588.  */
  589. struct DICIEvaluateSizeRec {
  590.     short                             defaultSizeIndex;            /* default size for this FS */
  591.     short                             numSizeEntries;                /* number of size entries */
  592.     short                             driveNumber;                /* drive number */
  593.     SizeListRecPtr                     sizeListPtr;                /* ptr to size entry table */
  594.     unsigned short                     sectorSize;                    /* bytes per sector */
  595. };
  596. typedef struct DICIEvaluateSizeRec DICIEvaluateSizeRec;
  597.  
  598. typedef DICIEvaluateSizeRec *            DICIEvaluateSizeRecPtr;
  599. /*
  600.  * paramBlock for the diCIExtendedZero call
  601.  */
  602. struct DICIExtendedZeroRec {
  603.     short                             driveNumber;                /* drive number */
  604.     StringPtr                         volNamePtr;                    /* ptr to volume name string */
  605.     short                             fsid;                        /* file system ID */
  606.     short                             volTypeSelector;            /* volume type selector, if supports more than 1 type */
  607.     unsigned short                     numDefectBlocks;            /* number of bad logical blocks */
  608.     unsigned short                     defectListSize;                /* size of the defect list buffer in bytes */
  609.     Ptr                             defectListPtr;                /* pointer to defect list buffer */
  610.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  611.     unsigned short                     sectorSize;                    /* bytes per sector */
  612.     Ptr                             extendedInfoPtr;            /* ptr to extended info */
  613. };
  614. typedef struct DICIExtendedZeroRec DICIExtendedZeroRec;
  615.  
  616. typedef DICIExtendedZeroRec *            DICIExtendedZeroRecPtr;
  617. /*
  618.  * paramBlock for the diCIValidateVolName call
  619.  */
  620. struct DICIValidateVolNameRec {
  621.     char                             theChar;                    /* the character to validate */
  622.     Boolean                         hasMessageBuffer;            /* false if no message */
  623.     short                             charOffset;                    /* position of the current character (first char = 1) */
  624.     StringPtr                         messageBufferPtr;            /* pointer to message buffer or nil */
  625.     short                             charByteType;                /* theChar's byte type (smSingleByte, smFirstByte, or smLastByte) */
  626. };
  627. typedef struct DICIValidateVolNameRec DICIValidateVolNameRec;
  628.  
  629. typedef DICIValidateVolNameRec *        DICIValidateVolNameRecPtr;
  630. /*
  631.  * paramBlock for the diCIGetVolTypeInfo call
  632.  */
  633. struct DICIGetVolTypeInfoRec {
  634.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  635.     unsigned short                     sectorSize;                    /* bytes per sector */
  636.     short                             numVolTypes;                /* number of volume types supported */
  637.     Str31                             volTypesBuffer[4];            /* 4 string buffers */
  638. };
  639. typedef struct DICIGetVolTypeInfoRec DICIGetVolTypeInfoRec;
  640.  
  641. typedef DICIGetVolTypeInfoRec *            DICIGetVolTypeInfoRecPtr;
  642. /*
  643.  * paramBlock for the diCIGetFormatString call
  644.  */
  645. struct DICIGetFormatStringRec {
  646.     unsigned long                     volSize;                    /* volume size in SECTORs */
  647.     unsigned short                     sectorSize;                    /* sector size */
  648.     short                             volTypeSelector;            /* volume type selector */
  649.     short                             stringKind;                    /* sub-function = type of string */
  650.     Str255                             stringBuffer;                /* string buffer */
  651. };
  652. typedef struct DICIGetFormatStringRec DICIGetFormatStringRec;
  653.  
  654. typedef DICIGetFormatStringRec *        DICIGetFormatStringRecPtr;
  655. /*
  656.  * paramBlock for the diCIGetExtendedFormatParams call
  657.  */
  658. struct DICIGetExtendedFormatRec {
  659.     short                             driveNumber;                /* drive number */
  660.     short                             volTypeSelector;            /* volume type selector or 0 */
  661.     unsigned long                     volSize;                    /* size of volume in SECTORs */
  662.     unsigned short                     sectorSize;                    /* bytes per sector */
  663.     FSSpecPtr                         fileSystemSpecPtr;            /* pointer to the foreign file system's FSSpec */
  664.     Ptr                             extendedInfoPtr;            /* pointer to extended parameter structure */
  665. };
  666. typedef struct DICIGetExtendedFormatRec DICIGetExtendedFormatRec;
  667.  
  668. typedef DICIGetExtendedFormatRec *        DICIGetExtendedFormatRecPtr;
  669. /*
  670.  *    File System Manager records
  671.  */
  672.  
  673. typedef CALLBACK_API( OSErr , FSDCommProcPtr )(short message, void *paramBlock, void *globalsPtr);
  674. typedef STACK_UPP_TYPE(FSDCommProcPtr)                             FSDCommUPP;
  675. enum { uppFSDCommProcInfo = 0x00000FA0 };                         /* pascal 2_bytes Func(2_bytes, 4_bytes, 4_bytes) */
  676. #define NewFSDCommProc(userRoutine)                             (FSDCommUPP)NewRoutineDescriptor((ProcPtr)(userRoutine), uppFSDCommProcInfo, GetCurrentArchitecture())
  677. #define CallFSDCommProc(userRoutine, message, paramBlock, globalsPtr)  CALL_THREE_PARAMETER_UPP((userRoutine), uppFSDCommProcInfo, (message), (paramBlock), (globalsPtr))
  678. typedef struct FSDRec                     FSDRec;
  679. struct FSDRec {
  680.     struct FSDRec *                    fsdLink;                    /* ptr to next */
  681.     short                             fsdLength;                    /* length of this FSD in BYTES */
  682.     short                             fsdVersion;                    /* version number */
  683.     short                             fileSystemFSID;                /* file system id */
  684.     Str31                             fileSystemName;                /* file system name */
  685.     FSSpec                             fileSystemSpec;                /* foreign file system's FSSpec */
  686.     Ptr                             fileSystemGlobalsPtr;        /* ptr to file system globals */
  687.     FSDCommProcPtr                     fileSystemCommProc;            /* communication proc with the FFS */
  688.     long                             reserved3;                    /* --reserved, must be zero-- */
  689.     long                             reserved2;                    /* --reserved, must be zero-- */
  690.     long                             reserved1;                    /* --reserved, must be zero-- */
  691.     HFSCIRec                         fsdHFSCI;                    /* HFS component interface    */
  692.     DICIRec                         fsdDICI;                    /* Disk Initialization component interface */
  693. };
  694.  
  695. typedef FSDRec *                        FSDRecPtr;
  696. struct FSMGetIconInfoRec {
  697.     long                             theIcon[32];                /* The ICN# structure */
  698.     long                             theMask[32];                /* The mask for the icon above */
  699.     Str255                             whereStr;
  700. };
  701. typedef struct FSMGetIconInfoRec FSMGetIconInfoRec;
  702.  
  703. typedef FSMGetIconInfoRec *                FSMGetIconInfoRecPtr;
  704. /*
  705.  * paramBlock for ffsGetIconMessage and fsmGetFSIconMessage
  706.  */
  707. struct FSMGetIconRec {
  708.     short                             refNum;                        /* target drive num or volume refnum */
  709.     FSMGetIconInfoRecPtr             iconBufferPtr;                /* pointer to icon buffer */
  710.     long                             requestSize;                /* requested size of the icon buffer */
  711.     long                             actualSize;                    /* actual size of the icon data returned */
  712.     SInt8                             iconType;                    /* kind of icon */
  713.     Boolean                         isEjectable;                /* true if the device is ejectable */
  714.     DrvQElPtr                         driveQElemPtr;                /* pointer to DQE */
  715.     FSSpecPtr                         fileSystemSpecPtr;            /* pointer to foreign file system's FSSpec */
  716.     long                             reserved1;                    /* --reserved, must be zero-- */
  717. };
  718. typedef struct FSMGetIconRec FSMGetIconRec;
  719.  
  720. typedef FSMGetIconRec *                    FSMGetIconRecPtr;
  721. /*
  722.  *    HFS Utility routine prototypes
  723.  */
  724. EXTERN_API( OSErr )
  725. UTAllocateFCB                    (short *                fileRefNum,
  726.                                  FCBRecPtr *            fileCtrlBlockPtr)                    TWOWORDINLINE(0x7000, 0xA824);
  727.  
  728. EXTERN_API( OSErr )
  729. UTReleaseFCB                    (short                     fileRefNum)                            TWOWORDINLINE(0x7001, 0xA824);
  730.  
  731. EXTERN_API( OSErr )
  732. UTLocateFCB                        (VCBPtr                 volCtrlBlockPtr,
  733.                                  unsigned long             fileNum,
  734.                                  StringPtr                 namePtr,
  735.                                  short *                fileRefNum,
  736.                                  FCBRecPtr *            fileCtrlBlockPtr)                    TWOWORDINLINE(0x7002, 0xA824);
  737.  
  738. EXTERN_API( OSErr )
  739. UTLocateNextFCB                    (VCBPtr                 volCtrlBlockPtr,
  740.                                  unsigned long             fileNum,
  741.                                  StringPtr                 namePtr,
  742.                                  short *                fileRefNum,
  743.                                  FCBRecPtr *            fileCtrlBlockPtr)                    TWOWORDINLINE(0x7003, 0xA824);
  744.  
  745. EXTERN_API( OSErr )
  746. UTIndexFCB                        (VCBPtr                 volCtrlBlockPtr,
  747.                                  short *                fileRefNum,
  748.                                  FCBRecPtr *            fileCtrlBlockPtr)                    TWOWORDINLINE(0x7004, 0xA824);
  749.  
  750. EXTERN_API( OSErr )
  751. UTResolveFCB                    (short                     fileRefNum,
  752.                                  FCBRecPtr *            fileCtrlBlockPtr)                    TWOWORDINLINE(0x7005, 0xA824);
  753.  
  754. EXTERN_API( OSErr )
  755. UTAllocateVCB                    (unsigned short *        sysVCBLength,
  756.                                  VCBPtr *                volCtrlBlockPtr,
  757.                                  unsigned short         addSize)                            TWOWORDINLINE(0x7006, 0xA824);
  758.  
  759. EXTERN_API( OSErr )
  760. UTAddNewVCB                        (short                     driveNum,
  761.                                  short *                vRefNum,
  762.                                  VCBPtr                 volCtrlBlockPtr)                    TWOWORDINLINE(0x7007, 0xA824);
  763.  
  764. EXTERN_API( OSErr )
  765. UTDisposeVCB                    (VCBPtr                 volCtrlBlockPtr)                    TWOWORDINLINE(0x7008, 0xA824);
  766.  
  767. EXTERN_API( OSErr )
  768. UTLocateVCBByRefNum                (short                     refNum,
  769.                                  short *                vRefNum,
  770.                                  VCBPtr *                volCtrlBlockPtr)                    TWOWORDINLINE(0x7009, 0xA824);
  771.  
  772. EXTERN_API( OSErr )
  773. UTLocateVCBByName                (StringPtr                 namePtr,
  774.                                  short *                moreMatches,
  775.                                  short *                vRefNum,
  776.                                  VCBPtr *                volCtrlBlockPtr)                    TWOWORDINLINE(0x700A, 0xA824);
  777.  
  778. EXTERN_API( OSErr )
  779. UTLocateNextVCB                    (StringPtr                 namePtr,
  780.                                  short *                moreMatches,
  781.                                  short *                vRefNum,
  782.                                  VCBPtr *                volCtrlBlockPtr)                    TWOWORDINLINE(0x700B, 0xA824);
  783.  
  784. EXTERN_API( OSErr )
  785. UTAllocateWDCB                    (WDPBPtr                 paramBlock)                            TWOWORDINLINE(0x700C, 0xA824);
  786.  
  787. EXTERN_API( OSErr )
  788. UTReleaseWDCB                    (short                     wdRefNum)                            TWOWORDINLINE(0x700D, 0xA824);
  789.  
  790. EXTERN_API( OSErr )
  791. UTResolveWDCB                    (long                     procID,
  792.                                  short                     wdIndex,
  793.                                  short                     wdRefNum,
  794.                                  WDCBRecPtr *            wdCtrlBlockPtr)                        TWOWORDINLINE(0x700E, 0xA824);
  795.  
  796. EXTERN_API( OSErr )
  797. UTFindDrive                        (short                     driveNum,
  798.                                  DrvQElPtr *            driveQElementPtr)                    TWOWORDINLINE(0x700F, 0xA824);
  799.  
  800. EXTERN_API( OSErr )
  801. UTAdjustEOF                        (short                     fileRefNum)                            TWOWORDINLINE(0x7010, 0xA824);
  802.  
  803. EXTERN_API( OSErr )
  804. UTSetDefaultVol                    (long                     nodeHint,
  805.                                  unsigned long             dirID,
  806.                                  short                     refNum)                                TWOWORDINLINE(0x7011, 0xA824);
  807.  
  808. EXTERN_API( OSErr )
  809. UTGetDefaultVol                    (WDPBPtr                 paramBlock)                            TWOWORDINLINE(0x7012, 0xA824);
  810.  
  811. EXTERN_API( OSErr )
  812. UTEjectVol                        (VCBPtr                 volCtrlBlockPtr)                    TWOWORDINLINE(0x702B, 0xA824);
  813.  
  814. EXTERN_API( OSErr )
  815. UTCheckWDRefNum                    (short                     wdRefNum)                            TWOWORDINLINE(0x7013, 0xA824);
  816.  
  817. EXTERN_API( OSErr )
  818. UTCheckFileRefNum                (short                     fileRefNum)                            TWOWORDINLINE(0x7014, 0xA824);
  819.  
  820. EXTERN_API( OSErr )
  821. UTCheckVolRefNum                (short                     vRefNum)                            TWOWORDINLINE(0x7015, 0xA824);
  822.  
  823. EXTERN_API( OSErr )
  824. UTCheckPermission                (VCBPtr                 volCtrlBlockPtr,
  825.                                  short *                modByte,
  826.                                  unsigned long             fileNum,
  827.                                  ParmBlkPtr             paramBlock)                            TWOWORDINLINE(0x7016, 0xA824);
  828.  
  829. EXTERN_API( OSErr )
  830. UTCheckVolOffline                (short                     vRefNum)                            TWOWORDINLINE(0x7017, 0xA824);
  831.  
  832. EXTERN_API( OSErr )
  833. UTCheckVolModifiable            (short                     vRefNum)                            TWOWORDINLINE(0x7018, 0xA824);
  834.  
  835. EXTERN_API( OSErr )
  836. UTCheckFileModifiable            (short                     fileRefNum)                            TWOWORDINLINE(0x7019, 0xA824);
  837.  
  838. EXTERN_API( OSErr )
  839. UTCheckDirBusy                    (VCBPtr                 volCtrlBlockPtr,
  840.                                  unsigned long             dirID)                                TWOWORDINLINE(0x701A, 0xA824);
  841.  
  842. EXTERN_API( OSErr )
  843. UTParsePathname                    (short *                volNamelength,
  844.                                  StringPtr                 namePtr)                            TWOWORDINLINE(0x701B, 0xA824);
  845.  
  846. EXTERN_API( OSErr )
  847. UTGetPathComponentName            (ParsePathRecPtr         parseRec)                            TWOWORDINLINE(0x701C, 0xA824);
  848.  
  849. EXTERN_API( OSErr )
  850. UTDetermineVol                    (ParmBlkPtr             paramBlock,
  851.                                  short *                status,
  852.                                  short *                moreMatches,
  853.                                  short *                vRefNum,
  854.                                  VCBPtr *                volCtrlBlockPtr)                    TWOWORDINLINE(0x701D, 0xA824);
  855.  
  856. EXTERN_API( OSErr )
  857. UTGetBlock                        (short                     refNum,
  858.                                  void *                    log2PhyProc,
  859.                                  unsigned long             blockNum,
  860.                                  short                     gbOption,
  861.                                  Ptr *                    buffer)                                TWOWORDINLINE(0x701F, 0xA824);
  862.  
  863. EXTERN_API( OSErr )
  864. UTReleaseBlock                    (Ptr                     buffer,
  865.                                  short                     rbOption)                            TWOWORDINLINE(0x7020, 0xA824);
  866.  
  867. EXTERN_API( OSErr )
  868. UTFlushCache                    (short                     refNum,
  869.                                  short                     fcOption)                            TWOWORDINLINE(0x7021, 0xA824);
  870.  
  871. EXTERN_API( OSErr )
  872. UTMarkDirty                        (Ptr                     buffer)                                TWOWORDINLINE(0x7023, 0xA824);
  873.  
  874. EXTERN_API( OSErr )
  875. UTTrashVolBlocks                (VCBPtr                 volCtrlBlockPtr)                    TWOWORDINLINE(0x7024, 0xA824);
  876.  
  877. EXTERN_API( OSErr )
  878. UTTrashFileBlocks                (VCBPtr                 volCtrlBlockPtr,
  879.                                  unsigned long             fileNum)                            TWOWORDINLINE(0x7025, 0xA824);
  880.  
  881. EXTERN_API( OSErr )
  882. UTTrashBlocks                    (unsigned long             beginPosition,
  883.                                  unsigned long             byteCount,
  884.                                  VCBPtr                 volCtrlBlockPtr,
  885.                                  short                     fileRefNum,
  886.                                  short                     tbOption)                            TWOWORDINLINE(0x7026, 0xA824);
  887.  
  888. EXTERN_API( OSErr )
  889. UTCacheReadIP                    (void *                    log2PhyProc,
  890.                                  unsigned long             filePosition,
  891.                                  Ptr                     ioBuffer,
  892.                                  short                     fileRefNum,
  893.                                  unsigned long             reqCount,
  894.                                  unsigned long *        actCount,
  895.                                  short                     cacheOption)                        TWOWORDINLINE(0x7027, 0xA824);
  896.  
  897. EXTERN_API( OSErr )
  898. UTCacheWriteIP                    (void *                    log2PhyProc,
  899.                                  unsigned long             filePosition,
  900.                                  Ptr                     ioBuffer,
  901.                                  short                     fileRefNum,
  902.                                  unsigned long             reqCount,
  903.                                  unsigned long *        actCount,
  904.                                  short                     cacheOption)                        TWOWORDINLINE(0x7028, 0xA824);
  905.  
  906. EXTERN_API( OSErr )
  907. UTBlockInFQHashP                (short                     vRefNum,
  908.                                  unsigned long             diskBlock)                            TWOWORDINLINE(0x702C, 0xA824);
  909.  
  910. EXTERN_API( OSErr )
  911. UTVolCacheReadIP                (VCBPtr                 volCtrlBlockPtr,
  912.                                  unsigned long             blockPosition,
  913.                                  Ptr                     ioBuffer,
  914.                                  unsigned long             reqCount,
  915.                                  unsigned long *        actCount,
  916.                                  short                     cacheOption)                        TWOWORDINLINE(0x7034, 0xA824);
  917.  
  918. EXTERN_API( OSErr )
  919. UTVolCacheWriteIP                (VCBPtr                 volCtrlBlockPtr,
  920.                                  unsigned long             blockPosition,
  921.                                  Ptr                     ioBuffer,
  922.                                  unsigned long             reqCount,
  923.                                  unsigned long *        actCount,
  924.                                  short                     cacheOption)                        TWOWORDINLINE(0x7035, 0xA824);
  925.  
  926.  
  927.  
  928. /*
  929.  *    File System Manager call prototypes
  930.  */
  931. EXTERN_API( OSErr )
  932. InstallFS                        (FSDRecPtr                 fsdPtr);
  933.  
  934. EXTERN_API( OSErr )
  935. RemoveFS                        (short                     fsid);
  936.  
  937. EXTERN_API( OSErr )
  938. SetFSInfo                        (short                     fsid,
  939.                                  short                     bufSize,
  940.                                  FSDRecPtr                 fsdPtr);
  941.  
  942. EXTERN_API( OSErr )
  943. GetFSInfo                        (short                     selector,
  944.                                  short                     key,
  945.                                  short *                bufSize,
  946.                                  FSDRecPtr                 fsdPtr);
  947.  
  948. EXTERN_API( OSErr )
  949. InformFSM                        (short                     theMessage,
  950.                                  void *                    paramBlock);
  951.  
  952. EXTERN_API( OSErr )
  953. InformFFS                        (short                     fsid,
  954.                                  void *                    paramBlock);
  955.  
  956.  
  957.  
  958.  
  959. #if PRAGMA_STRUCT_ALIGN
  960.     #pragma options align=reset
  961. #elif PRAGMA_STRUCT_PACKPUSH
  962.     #pragma pack(pop)
  963. #elif PRAGMA_STRUCT_PACK
  964.     #pragma pack()
  965. #endif
  966.  
  967. #ifdef PRAGMA_IMPORT_OFF
  968. #pragma import off
  969. #elif PRAGMA_IMPORT
  970. #pragma import reset
  971. #endif
  972.  
  973. #ifdef __cplusplus
  974. }
  975. #endif
  976.  
  977. #endif /* __FSM__ */
  978.  
  979.